using System;
using System.Text;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using AjaxControlToolkit;

namespace AjaxControlToolkit.Models.MSTest
{
	
    public partial class MaskedEditValidatorTests
    {


        
        [TestMethod]
        public void MaskedEditValidatorTests_Property_ErrorMessage_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.String expectedValue;
        
            
            try
            {
                expectedValue = null;
                objectUnderTest.ErrorMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ErrorMessage)) || expectedValue == objectUnderTest.ErrorMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "";
                objectUnderTest.ErrorMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ErrorMessage)) || expectedValue == objectUnderTest.ErrorMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1";
                objectUnderTest.ErrorMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ErrorMessage)) || expectedValue == objectUnderTest.ErrorMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "x";
                objectUnderTest.ErrorMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ErrorMessage)) || expectedValue == objectUnderTest.ErrorMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = ",";
                objectUnderTest.ErrorMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ErrorMessage)) || expectedValue == objectUnderTest.ErrorMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "123";
                objectUnderTest.ErrorMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ErrorMessage)) || expectedValue == objectUnderTest.ErrorMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "abc";
                objectUnderTest.ErrorMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ErrorMessage)) || expectedValue == objectUnderTest.ErrorMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1,2,3";
                objectUnderTest.ErrorMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ErrorMessage)) || expectedValue == objectUnderTest.ErrorMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a,b,c";
                objectUnderTest.ErrorMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ErrorMessage)) || expectedValue == objectUnderTest.ErrorMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1;2;3";
                objectUnderTest.ErrorMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ErrorMessage)) || expectedValue == objectUnderTest.ErrorMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a;b;c";
                objectUnderTest.ErrorMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ErrorMessage)) || expectedValue == objectUnderTest.ErrorMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "http://test.com";
                objectUnderTest.ErrorMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ErrorMessage)) || expectedValue == objectUnderTest.ErrorMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "test@test.com";
                objectUnderTest.ErrorMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ErrorMessage)) || expectedValue == objectUnderTest.ErrorMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void MaskedEditValidatorTests_Property_IsValidEmpty_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.Boolean expectedValue;
        
            
            try
            {
                expectedValue = true;
                objectUnderTest.IsValidEmpty = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.IsValidEmpty);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = false;
                objectUnderTest.IsValidEmpty = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.IsValidEmpty);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void MaskedEditValidatorTests_Property_TooltipMessage_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.String expectedValue;
        
            
            try
            {
                expectedValue = null;
                objectUnderTest.TooltipMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.TooltipMessage)) || expectedValue == objectUnderTest.TooltipMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "";
                objectUnderTest.TooltipMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.TooltipMessage)) || expectedValue == objectUnderTest.TooltipMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1";
                objectUnderTest.TooltipMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.TooltipMessage)) || expectedValue == objectUnderTest.TooltipMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "x";
                objectUnderTest.TooltipMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.TooltipMessage)) || expectedValue == objectUnderTest.TooltipMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = ",";
                objectUnderTest.TooltipMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.TooltipMessage)) || expectedValue == objectUnderTest.TooltipMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "123";
                objectUnderTest.TooltipMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.TooltipMessage)) || expectedValue == objectUnderTest.TooltipMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "abc";
                objectUnderTest.TooltipMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.TooltipMessage)) || expectedValue == objectUnderTest.TooltipMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1,2,3";
                objectUnderTest.TooltipMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.TooltipMessage)) || expectedValue == objectUnderTest.TooltipMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a,b,c";
                objectUnderTest.TooltipMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.TooltipMessage)) || expectedValue == objectUnderTest.TooltipMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1;2;3";
                objectUnderTest.TooltipMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.TooltipMessage)) || expectedValue == objectUnderTest.TooltipMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a;b;c";
                objectUnderTest.TooltipMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.TooltipMessage)) || expectedValue == objectUnderTest.TooltipMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "http://test.com";
                objectUnderTest.TooltipMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.TooltipMessage)) || expectedValue == objectUnderTest.TooltipMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "test@test.com";
                objectUnderTest.TooltipMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.TooltipMessage)) || expectedValue == objectUnderTest.TooltipMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void MaskedEditValidatorTests_Property_EmptyValueMessage_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.String expectedValue;
        
            
            try
            {
                expectedValue = null;
                objectUnderTest.EmptyValueMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.EmptyValueMessage)) || expectedValue == objectUnderTest.EmptyValueMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "";
                objectUnderTest.EmptyValueMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.EmptyValueMessage)) || expectedValue == objectUnderTest.EmptyValueMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1";
                objectUnderTest.EmptyValueMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.EmptyValueMessage)) || expectedValue == objectUnderTest.EmptyValueMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "x";
                objectUnderTest.EmptyValueMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.EmptyValueMessage)) || expectedValue == objectUnderTest.EmptyValueMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = ",";
                objectUnderTest.EmptyValueMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.EmptyValueMessage)) || expectedValue == objectUnderTest.EmptyValueMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "123";
                objectUnderTest.EmptyValueMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.EmptyValueMessage)) || expectedValue == objectUnderTest.EmptyValueMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "abc";
                objectUnderTest.EmptyValueMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.EmptyValueMessage)) || expectedValue == objectUnderTest.EmptyValueMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1,2,3";
                objectUnderTest.EmptyValueMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.EmptyValueMessage)) || expectedValue == objectUnderTest.EmptyValueMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a,b,c";
                objectUnderTest.EmptyValueMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.EmptyValueMessage)) || expectedValue == objectUnderTest.EmptyValueMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1;2;3";
                objectUnderTest.EmptyValueMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.EmptyValueMessage)) || expectedValue == objectUnderTest.EmptyValueMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a;b;c";
                objectUnderTest.EmptyValueMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.EmptyValueMessage)) || expectedValue == objectUnderTest.EmptyValueMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "http://test.com";
                objectUnderTest.EmptyValueMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.EmptyValueMessage)) || expectedValue == objectUnderTest.EmptyValueMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "test@test.com";
                objectUnderTest.EmptyValueMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.EmptyValueMessage)) || expectedValue == objectUnderTest.EmptyValueMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void MaskedEditValidatorTests_Property_EmptyValueBlurredText_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.String expectedValue;
        
            
            try
            {
                expectedValue = null;
                objectUnderTest.EmptyValueBlurredText = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.EmptyValueBlurredText)) || expectedValue == objectUnderTest.EmptyValueBlurredText);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "";
                objectUnderTest.EmptyValueBlurredText = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.EmptyValueBlurredText)) || expectedValue == objectUnderTest.EmptyValueBlurredText);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1";
                objectUnderTest.EmptyValueBlurredText = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.EmptyValueBlurredText)) || expectedValue == objectUnderTest.EmptyValueBlurredText);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "x";
                objectUnderTest.EmptyValueBlurredText = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.EmptyValueBlurredText)) || expectedValue == objectUnderTest.EmptyValueBlurredText);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = ",";
                objectUnderTest.EmptyValueBlurredText = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.EmptyValueBlurredText)) || expectedValue == objectUnderTest.EmptyValueBlurredText);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "123";
                objectUnderTest.EmptyValueBlurredText = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.EmptyValueBlurredText)) || expectedValue == objectUnderTest.EmptyValueBlurredText);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "abc";
                objectUnderTest.EmptyValueBlurredText = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.EmptyValueBlurredText)) || expectedValue == objectUnderTest.EmptyValueBlurredText);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1,2,3";
                objectUnderTest.EmptyValueBlurredText = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.EmptyValueBlurredText)) || expectedValue == objectUnderTest.EmptyValueBlurredText);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a,b,c";
                objectUnderTest.EmptyValueBlurredText = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.EmptyValueBlurredText)) || expectedValue == objectUnderTest.EmptyValueBlurredText);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1;2;3";
                objectUnderTest.EmptyValueBlurredText = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.EmptyValueBlurredText)) || expectedValue == objectUnderTest.EmptyValueBlurredText);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a;b;c";
                objectUnderTest.EmptyValueBlurredText = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.EmptyValueBlurredText)) || expectedValue == objectUnderTest.EmptyValueBlurredText);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "http://test.com";
                objectUnderTest.EmptyValueBlurredText = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.EmptyValueBlurredText)) || expectedValue == objectUnderTest.EmptyValueBlurredText);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "test@test.com";
                objectUnderTest.EmptyValueBlurredText = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.EmptyValueBlurredText)) || expectedValue == objectUnderTest.EmptyValueBlurredText);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void MaskedEditValidatorTests_Property_InvalidValueMessage_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.String expectedValue;
        
            
            try
            {
                expectedValue = null;
                objectUnderTest.InvalidValueMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.InvalidValueMessage)) || expectedValue == objectUnderTest.InvalidValueMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "";
                objectUnderTest.InvalidValueMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.InvalidValueMessage)) || expectedValue == objectUnderTest.InvalidValueMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1";
                objectUnderTest.InvalidValueMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.InvalidValueMessage)) || expectedValue == objectUnderTest.InvalidValueMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "x";
                objectUnderTest.InvalidValueMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.InvalidValueMessage)) || expectedValue == objectUnderTest.InvalidValueMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = ",";
                objectUnderTest.InvalidValueMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.InvalidValueMessage)) || expectedValue == objectUnderTest.InvalidValueMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "123";
                objectUnderTest.InvalidValueMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.InvalidValueMessage)) || expectedValue == objectUnderTest.InvalidValueMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "abc";
                objectUnderTest.InvalidValueMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.InvalidValueMessage)) || expectedValue == objectUnderTest.InvalidValueMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1,2,3";
                objectUnderTest.InvalidValueMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.InvalidValueMessage)) || expectedValue == objectUnderTest.InvalidValueMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a,b,c";
                objectUnderTest.InvalidValueMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.InvalidValueMessage)) || expectedValue == objectUnderTest.InvalidValueMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1;2;3";
                objectUnderTest.InvalidValueMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.InvalidValueMessage)) || expectedValue == objectUnderTest.InvalidValueMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a;b;c";
                objectUnderTest.InvalidValueMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.InvalidValueMessage)) || expectedValue == objectUnderTest.InvalidValueMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "http://test.com";
                objectUnderTest.InvalidValueMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.InvalidValueMessage)) || expectedValue == objectUnderTest.InvalidValueMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "test@test.com";
                objectUnderTest.InvalidValueMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.InvalidValueMessage)) || expectedValue == objectUnderTest.InvalidValueMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void MaskedEditValidatorTests_Property_InvalidValueBlurredMessage_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.String expectedValue;
        
            
            try
            {
                expectedValue = null;
                objectUnderTest.InvalidValueBlurredMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.InvalidValueBlurredMessage)) || expectedValue == objectUnderTest.InvalidValueBlurredMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "";
                objectUnderTest.InvalidValueBlurredMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.InvalidValueBlurredMessage)) || expectedValue == objectUnderTest.InvalidValueBlurredMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1";
                objectUnderTest.InvalidValueBlurredMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.InvalidValueBlurredMessage)) || expectedValue == objectUnderTest.InvalidValueBlurredMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "x";
                objectUnderTest.InvalidValueBlurredMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.InvalidValueBlurredMessage)) || expectedValue == objectUnderTest.InvalidValueBlurredMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = ",";
                objectUnderTest.InvalidValueBlurredMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.InvalidValueBlurredMessage)) || expectedValue == objectUnderTest.InvalidValueBlurredMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "123";
                objectUnderTest.InvalidValueBlurredMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.InvalidValueBlurredMessage)) || expectedValue == objectUnderTest.InvalidValueBlurredMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "abc";
                objectUnderTest.InvalidValueBlurredMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.InvalidValueBlurredMessage)) || expectedValue == objectUnderTest.InvalidValueBlurredMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1,2,3";
                objectUnderTest.InvalidValueBlurredMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.InvalidValueBlurredMessage)) || expectedValue == objectUnderTest.InvalidValueBlurredMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a,b,c";
                objectUnderTest.InvalidValueBlurredMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.InvalidValueBlurredMessage)) || expectedValue == objectUnderTest.InvalidValueBlurredMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1;2;3";
                objectUnderTest.InvalidValueBlurredMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.InvalidValueBlurredMessage)) || expectedValue == objectUnderTest.InvalidValueBlurredMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a;b;c";
                objectUnderTest.InvalidValueBlurredMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.InvalidValueBlurredMessage)) || expectedValue == objectUnderTest.InvalidValueBlurredMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "http://test.com";
                objectUnderTest.InvalidValueBlurredMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.InvalidValueBlurredMessage)) || expectedValue == objectUnderTest.InvalidValueBlurredMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "test@test.com";
                objectUnderTest.InvalidValueBlurredMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.InvalidValueBlurredMessage)) || expectedValue == objectUnderTest.InvalidValueBlurredMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void MaskedEditValidatorTests_Property_MaximumValue_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.String expectedValue;
        
            
            try
            {
                expectedValue = null;
                objectUnderTest.MaximumValue = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.MaximumValue)) || expectedValue == objectUnderTest.MaximumValue);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "";
                objectUnderTest.MaximumValue = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.MaximumValue)) || expectedValue == objectUnderTest.MaximumValue);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1";
                objectUnderTest.MaximumValue = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.MaximumValue)) || expectedValue == objectUnderTest.MaximumValue);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "x";
                objectUnderTest.MaximumValue = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.MaximumValue)) || expectedValue == objectUnderTest.MaximumValue);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = ",";
                objectUnderTest.MaximumValue = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.MaximumValue)) || expectedValue == objectUnderTest.MaximumValue);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "123";
                objectUnderTest.MaximumValue = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.MaximumValue)) || expectedValue == objectUnderTest.MaximumValue);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "abc";
                objectUnderTest.MaximumValue = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.MaximumValue)) || expectedValue == objectUnderTest.MaximumValue);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1,2,3";
                objectUnderTest.MaximumValue = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.MaximumValue)) || expectedValue == objectUnderTest.MaximumValue);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a,b,c";
                objectUnderTest.MaximumValue = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.MaximumValue)) || expectedValue == objectUnderTest.MaximumValue);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1;2;3";
                objectUnderTest.MaximumValue = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.MaximumValue)) || expectedValue == objectUnderTest.MaximumValue);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a;b;c";
                objectUnderTest.MaximumValue = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.MaximumValue)) || expectedValue == objectUnderTest.MaximumValue);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "http://test.com";
                objectUnderTest.MaximumValue = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.MaximumValue)) || expectedValue == objectUnderTest.MaximumValue);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "test@test.com";
                objectUnderTest.MaximumValue = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.MaximumValue)) || expectedValue == objectUnderTest.MaximumValue);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void MaskedEditValidatorTests_Property_MaximumValueMessage_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.String expectedValue;
        
            
            try
            {
                expectedValue = null;
                objectUnderTest.MaximumValueMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.MaximumValueMessage)) || expectedValue == objectUnderTest.MaximumValueMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "";
                objectUnderTest.MaximumValueMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.MaximumValueMessage)) || expectedValue == objectUnderTest.MaximumValueMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1";
                objectUnderTest.MaximumValueMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.MaximumValueMessage)) || expectedValue == objectUnderTest.MaximumValueMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "x";
                objectUnderTest.MaximumValueMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.MaximumValueMessage)) || expectedValue == objectUnderTest.MaximumValueMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = ",";
                objectUnderTest.MaximumValueMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.MaximumValueMessage)) || expectedValue == objectUnderTest.MaximumValueMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "123";
                objectUnderTest.MaximumValueMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.MaximumValueMessage)) || expectedValue == objectUnderTest.MaximumValueMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "abc";
                objectUnderTest.MaximumValueMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.MaximumValueMessage)) || expectedValue == objectUnderTest.MaximumValueMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1,2,3";
                objectUnderTest.MaximumValueMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.MaximumValueMessage)) || expectedValue == objectUnderTest.MaximumValueMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a,b,c";
                objectUnderTest.MaximumValueMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.MaximumValueMessage)) || expectedValue == objectUnderTest.MaximumValueMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1;2;3";
                objectUnderTest.MaximumValueMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.MaximumValueMessage)) || expectedValue == objectUnderTest.MaximumValueMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a;b;c";
                objectUnderTest.MaximumValueMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.MaximumValueMessage)) || expectedValue == objectUnderTest.MaximumValueMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "http://test.com";
                objectUnderTest.MaximumValueMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.MaximumValueMessage)) || expectedValue == objectUnderTest.MaximumValueMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "test@test.com";
                objectUnderTest.MaximumValueMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.MaximumValueMessage)) || expectedValue == objectUnderTest.MaximumValueMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void MaskedEditValidatorTests_Property_MaximumValueBlurredMessage_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.String expectedValue;
        
            
            try
            {
                expectedValue = null;
                objectUnderTest.MaximumValueBlurredMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.MaximumValueBlurredMessage)) || expectedValue == objectUnderTest.MaximumValueBlurredMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "";
                objectUnderTest.MaximumValueBlurredMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.MaximumValueBlurredMessage)) || expectedValue == objectUnderTest.MaximumValueBlurredMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1";
                objectUnderTest.MaximumValueBlurredMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.MaximumValueBlurredMessage)) || expectedValue == objectUnderTest.MaximumValueBlurredMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "x";
                objectUnderTest.MaximumValueBlurredMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.MaximumValueBlurredMessage)) || expectedValue == objectUnderTest.MaximumValueBlurredMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = ",";
                objectUnderTest.MaximumValueBlurredMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.MaximumValueBlurredMessage)) || expectedValue == objectUnderTest.MaximumValueBlurredMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "123";
                objectUnderTest.MaximumValueBlurredMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.MaximumValueBlurredMessage)) || expectedValue == objectUnderTest.MaximumValueBlurredMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "abc";
                objectUnderTest.MaximumValueBlurredMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.MaximumValueBlurredMessage)) || expectedValue == objectUnderTest.MaximumValueBlurredMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1,2,3";
                objectUnderTest.MaximumValueBlurredMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.MaximumValueBlurredMessage)) || expectedValue == objectUnderTest.MaximumValueBlurredMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a,b,c";
                objectUnderTest.MaximumValueBlurredMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.MaximumValueBlurredMessage)) || expectedValue == objectUnderTest.MaximumValueBlurredMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1;2;3";
                objectUnderTest.MaximumValueBlurredMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.MaximumValueBlurredMessage)) || expectedValue == objectUnderTest.MaximumValueBlurredMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a;b;c";
                objectUnderTest.MaximumValueBlurredMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.MaximumValueBlurredMessage)) || expectedValue == objectUnderTest.MaximumValueBlurredMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "http://test.com";
                objectUnderTest.MaximumValueBlurredMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.MaximumValueBlurredMessage)) || expectedValue == objectUnderTest.MaximumValueBlurredMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "test@test.com";
                objectUnderTest.MaximumValueBlurredMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.MaximumValueBlurredMessage)) || expectedValue == objectUnderTest.MaximumValueBlurredMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void MaskedEditValidatorTests_Property_ClientValidationFunction_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.String expectedValue;
        
            
            try
            {
                expectedValue = null;
                objectUnderTest.ClientValidationFunction = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ClientValidationFunction)) || expectedValue == objectUnderTest.ClientValidationFunction);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "";
                objectUnderTest.ClientValidationFunction = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ClientValidationFunction)) || expectedValue == objectUnderTest.ClientValidationFunction);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1";
                objectUnderTest.ClientValidationFunction = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ClientValidationFunction)) || expectedValue == objectUnderTest.ClientValidationFunction);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "x";
                objectUnderTest.ClientValidationFunction = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ClientValidationFunction)) || expectedValue == objectUnderTest.ClientValidationFunction);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = ",";
                objectUnderTest.ClientValidationFunction = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ClientValidationFunction)) || expectedValue == objectUnderTest.ClientValidationFunction);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "123";
                objectUnderTest.ClientValidationFunction = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ClientValidationFunction)) || expectedValue == objectUnderTest.ClientValidationFunction);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "abc";
                objectUnderTest.ClientValidationFunction = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ClientValidationFunction)) || expectedValue == objectUnderTest.ClientValidationFunction);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1,2,3";
                objectUnderTest.ClientValidationFunction = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ClientValidationFunction)) || expectedValue == objectUnderTest.ClientValidationFunction);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a,b,c";
                objectUnderTest.ClientValidationFunction = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ClientValidationFunction)) || expectedValue == objectUnderTest.ClientValidationFunction);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1;2;3";
                objectUnderTest.ClientValidationFunction = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ClientValidationFunction)) || expectedValue == objectUnderTest.ClientValidationFunction);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a;b;c";
                objectUnderTest.ClientValidationFunction = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ClientValidationFunction)) || expectedValue == objectUnderTest.ClientValidationFunction);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "http://test.com";
                objectUnderTest.ClientValidationFunction = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ClientValidationFunction)) || expectedValue == objectUnderTest.ClientValidationFunction);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "test@test.com";
                objectUnderTest.ClientValidationFunction = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ClientValidationFunction)) || expectedValue == objectUnderTest.ClientValidationFunction);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void MaskedEditValidatorTests_Property_InitialValue_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.String expectedValue;
        
            
            try
            {
                expectedValue = null;
                objectUnderTest.InitialValue = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.InitialValue)) || expectedValue == objectUnderTest.InitialValue);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "";
                objectUnderTest.InitialValue = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.InitialValue)) || expectedValue == objectUnderTest.InitialValue);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1";
                objectUnderTest.InitialValue = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.InitialValue)) || expectedValue == objectUnderTest.InitialValue);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "x";
                objectUnderTest.InitialValue = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.InitialValue)) || expectedValue == objectUnderTest.InitialValue);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = ",";
                objectUnderTest.InitialValue = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.InitialValue)) || expectedValue == objectUnderTest.InitialValue);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "123";
                objectUnderTest.InitialValue = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.InitialValue)) || expectedValue == objectUnderTest.InitialValue);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "abc";
                objectUnderTest.InitialValue = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.InitialValue)) || expectedValue == objectUnderTest.InitialValue);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1,2,3";
                objectUnderTest.InitialValue = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.InitialValue)) || expectedValue == objectUnderTest.InitialValue);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a,b,c";
                objectUnderTest.InitialValue = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.InitialValue)) || expectedValue == objectUnderTest.InitialValue);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1;2;3";
                objectUnderTest.InitialValue = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.InitialValue)) || expectedValue == objectUnderTest.InitialValue);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a;b;c";
                objectUnderTest.InitialValue = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.InitialValue)) || expectedValue == objectUnderTest.InitialValue);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "http://test.com";
                objectUnderTest.InitialValue = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.InitialValue)) || expectedValue == objectUnderTest.InitialValue);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "test@test.com";
                objectUnderTest.InitialValue = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.InitialValue)) || expectedValue == objectUnderTest.InitialValue);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void MaskedEditValidatorTests_Property_ValidationExpression_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.String expectedValue;
        
            
            try
            {
                expectedValue = null;
                objectUnderTest.ValidationExpression = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ValidationExpression)) || expectedValue == objectUnderTest.ValidationExpression);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "";
                objectUnderTest.ValidationExpression = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ValidationExpression)) || expectedValue == objectUnderTest.ValidationExpression);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1";
                objectUnderTest.ValidationExpression = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ValidationExpression)) || expectedValue == objectUnderTest.ValidationExpression);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "x";
                objectUnderTest.ValidationExpression = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ValidationExpression)) || expectedValue == objectUnderTest.ValidationExpression);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = ",";
                objectUnderTest.ValidationExpression = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ValidationExpression)) || expectedValue == objectUnderTest.ValidationExpression);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "123";
                objectUnderTest.ValidationExpression = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ValidationExpression)) || expectedValue == objectUnderTest.ValidationExpression);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "abc";
                objectUnderTest.ValidationExpression = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ValidationExpression)) || expectedValue == objectUnderTest.ValidationExpression);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1,2,3";
                objectUnderTest.ValidationExpression = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ValidationExpression)) || expectedValue == objectUnderTest.ValidationExpression);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a,b,c";
                objectUnderTest.ValidationExpression = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ValidationExpression)) || expectedValue == objectUnderTest.ValidationExpression);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1;2;3";
                objectUnderTest.ValidationExpression = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ValidationExpression)) || expectedValue == objectUnderTest.ValidationExpression);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a;b;c";
                objectUnderTest.ValidationExpression = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ValidationExpression)) || expectedValue == objectUnderTest.ValidationExpression);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "http://test.com";
                objectUnderTest.ValidationExpression = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ValidationExpression)) || expectedValue == objectUnderTest.ValidationExpression);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "test@test.com";
                objectUnderTest.ValidationExpression = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ValidationExpression)) || expectedValue == objectUnderTest.ValidationExpression);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void MaskedEditValidatorTests_Property_MinimumValue_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.String expectedValue;
        
            
            try
            {
                expectedValue = null;
                objectUnderTest.MinimumValue = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.MinimumValue)) || expectedValue == objectUnderTest.MinimumValue);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "";
                objectUnderTest.MinimumValue = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.MinimumValue)) || expectedValue == objectUnderTest.MinimumValue);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1";
                objectUnderTest.MinimumValue = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.MinimumValue)) || expectedValue == objectUnderTest.MinimumValue);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "x";
                objectUnderTest.MinimumValue = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.MinimumValue)) || expectedValue == objectUnderTest.MinimumValue);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = ",";
                objectUnderTest.MinimumValue = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.MinimumValue)) || expectedValue == objectUnderTest.MinimumValue);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "123";
                objectUnderTest.MinimumValue = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.MinimumValue)) || expectedValue == objectUnderTest.MinimumValue);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "abc";
                objectUnderTest.MinimumValue = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.MinimumValue)) || expectedValue == objectUnderTest.MinimumValue);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1,2,3";
                objectUnderTest.MinimumValue = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.MinimumValue)) || expectedValue == objectUnderTest.MinimumValue);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a,b,c";
                objectUnderTest.MinimumValue = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.MinimumValue)) || expectedValue == objectUnderTest.MinimumValue);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1;2;3";
                objectUnderTest.MinimumValue = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.MinimumValue)) || expectedValue == objectUnderTest.MinimumValue);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a;b;c";
                objectUnderTest.MinimumValue = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.MinimumValue)) || expectedValue == objectUnderTest.MinimumValue);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "http://test.com";
                objectUnderTest.MinimumValue = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.MinimumValue)) || expectedValue == objectUnderTest.MinimumValue);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "test@test.com";
                objectUnderTest.MinimumValue = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.MinimumValue)) || expectedValue == objectUnderTest.MinimumValue);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void MaskedEditValidatorTests_Property_MinimumValueMessage_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.String expectedValue;
        
            
            try
            {
                expectedValue = null;
                objectUnderTest.MinimumValueMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.MinimumValueMessage)) || expectedValue == objectUnderTest.MinimumValueMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "";
                objectUnderTest.MinimumValueMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.MinimumValueMessage)) || expectedValue == objectUnderTest.MinimumValueMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1";
                objectUnderTest.MinimumValueMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.MinimumValueMessage)) || expectedValue == objectUnderTest.MinimumValueMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "x";
                objectUnderTest.MinimumValueMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.MinimumValueMessage)) || expectedValue == objectUnderTest.MinimumValueMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = ",";
                objectUnderTest.MinimumValueMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.MinimumValueMessage)) || expectedValue == objectUnderTest.MinimumValueMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "123";
                objectUnderTest.MinimumValueMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.MinimumValueMessage)) || expectedValue == objectUnderTest.MinimumValueMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "abc";
                objectUnderTest.MinimumValueMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.MinimumValueMessage)) || expectedValue == objectUnderTest.MinimumValueMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1,2,3";
                objectUnderTest.MinimumValueMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.MinimumValueMessage)) || expectedValue == objectUnderTest.MinimumValueMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a,b,c";
                objectUnderTest.MinimumValueMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.MinimumValueMessage)) || expectedValue == objectUnderTest.MinimumValueMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1;2;3";
                objectUnderTest.MinimumValueMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.MinimumValueMessage)) || expectedValue == objectUnderTest.MinimumValueMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a;b;c";
                objectUnderTest.MinimumValueMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.MinimumValueMessage)) || expectedValue == objectUnderTest.MinimumValueMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "http://test.com";
                objectUnderTest.MinimumValueMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.MinimumValueMessage)) || expectedValue == objectUnderTest.MinimumValueMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "test@test.com";
                objectUnderTest.MinimumValueMessage = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.MinimumValueMessage)) || expectedValue == objectUnderTest.MinimumValueMessage);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void MaskedEditValidatorTests_Property_MinimumValueBlurredText_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.String expectedValue;
        
            
            try
            {
                expectedValue = null;
                objectUnderTest.MinimumValueBlurredText = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.MinimumValueBlurredText)) || expectedValue == objectUnderTest.MinimumValueBlurredText);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "";
                objectUnderTest.MinimumValueBlurredText = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.MinimumValueBlurredText)) || expectedValue == objectUnderTest.MinimumValueBlurredText);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1";
                objectUnderTest.MinimumValueBlurredText = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.MinimumValueBlurredText)) || expectedValue == objectUnderTest.MinimumValueBlurredText);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "x";
                objectUnderTest.MinimumValueBlurredText = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.MinimumValueBlurredText)) || expectedValue == objectUnderTest.MinimumValueBlurredText);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = ",";
                objectUnderTest.MinimumValueBlurredText = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.MinimumValueBlurredText)) || expectedValue == objectUnderTest.MinimumValueBlurredText);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "123";
                objectUnderTest.MinimumValueBlurredText = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.MinimumValueBlurredText)) || expectedValue == objectUnderTest.MinimumValueBlurredText);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "abc";
                objectUnderTest.MinimumValueBlurredText = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.MinimumValueBlurredText)) || expectedValue == objectUnderTest.MinimumValueBlurredText);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1,2,3";
                objectUnderTest.MinimumValueBlurredText = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.MinimumValueBlurredText)) || expectedValue == objectUnderTest.MinimumValueBlurredText);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a,b,c";
                objectUnderTest.MinimumValueBlurredText = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.MinimumValueBlurredText)) || expectedValue == objectUnderTest.MinimumValueBlurredText);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1;2;3";
                objectUnderTest.MinimumValueBlurredText = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.MinimumValueBlurredText)) || expectedValue == objectUnderTest.MinimumValueBlurredText);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a;b;c";
                objectUnderTest.MinimumValueBlurredText = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.MinimumValueBlurredText)) || expectedValue == objectUnderTest.MinimumValueBlurredText);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "http://test.com";
                objectUnderTest.MinimumValueBlurredText = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.MinimumValueBlurredText)) || expectedValue == objectUnderTest.MinimumValueBlurredText);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "test@test.com";
                objectUnderTest.MinimumValueBlurredText = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.MinimumValueBlurredText)) || expectedValue == objectUnderTest.MinimumValueBlurredText);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void MaskedEditValidatorTests_Property_ControlExtender_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.String expectedValue;
        
            
            try
            {
                expectedValue = null;
                objectUnderTest.ControlExtender = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ControlExtender)) || expectedValue == objectUnderTest.ControlExtender);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "";
                objectUnderTest.ControlExtender = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ControlExtender)) || expectedValue == objectUnderTest.ControlExtender);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1";
                objectUnderTest.ControlExtender = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ControlExtender)) || expectedValue == objectUnderTest.ControlExtender);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "x";
                objectUnderTest.ControlExtender = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ControlExtender)) || expectedValue == objectUnderTest.ControlExtender);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = ",";
                objectUnderTest.ControlExtender = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ControlExtender)) || expectedValue == objectUnderTest.ControlExtender);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "123";
                objectUnderTest.ControlExtender = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ControlExtender)) || expectedValue == objectUnderTest.ControlExtender);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "abc";
                objectUnderTest.ControlExtender = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ControlExtender)) || expectedValue == objectUnderTest.ControlExtender);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1,2,3";
                objectUnderTest.ControlExtender = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ControlExtender)) || expectedValue == objectUnderTest.ControlExtender);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a,b,c";
                objectUnderTest.ControlExtender = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ControlExtender)) || expectedValue == objectUnderTest.ControlExtender);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1;2;3";
                objectUnderTest.ControlExtender = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ControlExtender)) || expectedValue == objectUnderTest.ControlExtender);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a;b;c";
                objectUnderTest.ControlExtender = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ControlExtender)) || expectedValue == objectUnderTest.ControlExtender);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "http://test.com";
                objectUnderTest.ControlExtender = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ControlExtender)) || expectedValue == objectUnderTest.ControlExtender);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "test@test.com";
                objectUnderTest.ControlExtender = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ControlExtender)) || expectedValue == objectUnderTest.ControlExtender);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void MaskedEditValidatorTests_Property_AssociatedControlID_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.String expectedValue;
        
            
            try
            {
                expectedValue = null;
                objectUnderTest.AssociatedControlID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AssociatedControlID)) || expectedValue == objectUnderTest.AssociatedControlID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "";
                objectUnderTest.AssociatedControlID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AssociatedControlID)) || expectedValue == objectUnderTest.AssociatedControlID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1";
                objectUnderTest.AssociatedControlID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AssociatedControlID)) || expectedValue == objectUnderTest.AssociatedControlID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "x";
                objectUnderTest.AssociatedControlID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AssociatedControlID)) || expectedValue == objectUnderTest.AssociatedControlID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = ",";
                objectUnderTest.AssociatedControlID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AssociatedControlID)) || expectedValue == objectUnderTest.AssociatedControlID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "123";
                objectUnderTest.AssociatedControlID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AssociatedControlID)) || expectedValue == objectUnderTest.AssociatedControlID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "abc";
                objectUnderTest.AssociatedControlID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AssociatedControlID)) || expectedValue == objectUnderTest.AssociatedControlID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1,2,3";
                objectUnderTest.AssociatedControlID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AssociatedControlID)) || expectedValue == objectUnderTest.AssociatedControlID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a,b,c";
                objectUnderTest.AssociatedControlID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AssociatedControlID)) || expectedValue == objectUnderTest.AssociatedControlID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1;2;3";
                objectUnderTest.AssociatedControlID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AssociatedControlID)) || expectedValue == objectUnderTest.AssociatedControlID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a;b;c";
                objectUnderTest.AssociatedControlID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AssociatedControlID)) || expectedValue == objectUnderTest.AssociatedControlID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "http://test.com";
                objectUnderTest.AssociatedControlID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AssociatedControlID)) || expectedValue == objectUnderTest.AssociatedControlID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "test@test.com";
                objectUnderTest.AssociatedControlID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AssociatedControlID)) || expectedValue == objectUnderTest.AssociatedControlID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void MaskedEditValidatorTests_Property_ControlToValidate_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.String expectedValue;
        
            
            try
            {
                expectedValue = null;
                objectUnderTest.ControlToValidate = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ControlToValidate)) || expectedValue == objectUnderTest.ControlToValidate);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "";
                objectUnderTest.ControlToValidate = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ControlToValidate)) || expectedValue == objectUnderTest.ControlToValidate);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1";
                objectUnderTest.ControlToValidate = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ControlToValidate)) || expectedValue == objectUnderTest.ControlToValidate);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "x";
                objectUnderTest.ControlToValidate = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ControlToValidate)) || expectedValue == objectUnderTest.ControlToValidate);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = ",";
                objectUnderTest.ControlToValidate = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ControlToValidate)) || expectedValue == objectUnderTest.ControlToValidate);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "123";
                objectUnderTest.ControlToValidate = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ControlToValidate)) || expectedValue == objectUnderTest.ControlToValidate);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "abc";
                objectUnderTest.ControlToValidate = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ControlToValidate)) || expectedValue == objectUnderTest.ControlToValidate);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1,2,3";
                objectUnderTest.ControlToValidate = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ControlToValidate)) || expectedValue == objectUnderTest.ControlToValidate);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a,b,c";
                objectUnderTest.ControlToValidate = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ControlToValidate)) || expectedValue == objectUnderTest.ControlToValidate);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1;2;3";
                objectUnderTest.ControlToValidate = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ControlToValidate)) || expectedValue == objectUnderTest.ControlToValidate);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a;b;c";
                objectUnderTest.ControlToValidate = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ControlToValidate)) || expectedValue == objectUnderTest.ControlToValidate);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "http://test.com";
                objectUnderTest.ControlToValidate = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ControlToValidate)) || expectedValue == objectUnderTest.ControlToValidate);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "test@test.com";
                objectUnderTest.ControlToValidate = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ControlToValidate)) || expectedValue == objectUnderTest.ControlToValidate);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void MaskedEditValidatorTests_Property_EnableClientScript_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.Boolean expectedValue;
        
            
            try
            {
                expectedValue = true;
                objectUnderTest.EnableClientScript = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.EnableClientScript);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = false;
                objectUnderTest.EnableClientScript = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.EnableClientScript);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void MaskedEditValidatorTests_Property_Enabled_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.Boolean expectedValue;
        
            
            try
            {
                expectedValue = true;
                objectUnderTest.Enabled = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.Enabled);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = false;
                objectUnderTest.Enabled = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.Enabled);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void MaskedEditValidatorTests_Property_IsValid_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.Boolean expectedValue;
        
            
            try
            {
                expectedValue = true;
                objectUnderTest.IsValid = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.IsValid);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = false;
                objectUnderTest.IsValid = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.IsValid);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void MaskedEditValidatorTests_Property_SetFocusOnError_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.Boolean expectedValue;
        
            
            try
            {
                expectedValue = true;
                objectUnderTest.SetFocusOnError = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.SetFocusOnError);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = false;
                objectUnderTest.SetFocusOnError = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.SetFocusOnError);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void MaskedEditValidatorTests_Property_Text_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.String expectedValue;
        
            
            try
            {
                expectedValue = null;
                objectUnderTest.Text = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.Text)) || expectedValue == objectUnderTest.Text);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "";
                objectUnderTest.Text = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.Text)) || expectedValue == objectUnderTest.Text);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1";
                objectUnderTest.Text = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.Text)) || expectedValue == objectUnderTest.Text);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "x";
                objectUnderTest.Text = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.Text)) || expectedValue == objectUnderTest.Text);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = ",";
                objectUnderTest.Text = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.Text)) || expectedValue == objectUnderTest.Text);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "123";
                objectUnderTest.Text = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.Text)) || expectedValue == objectUnderTest.Text);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "abc";
                objectUnderTest.Text = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.Text)) || expectedValue == objectUnderTest.Text);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1,2,3";
                objectUnderTest.Text = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.Text)) || expectedValue == objectUnderTest.Text);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a,b,c";
                objectUnderTest.Text = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.Text)) || expectedValue == objectUnderTest.Text);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1;2;3";
                objectUnderTest.Text = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.Text)) || expectedValue == objectUnderTest.Text);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a;b;c";
                objectUnderTest.Text = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.Text)) || expectedValue == objectUnderTest.Text);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "http://test.com";
                objectUnderTest.Text = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.Text)) || expectedValue == objectUnderTest.Text);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "test@test.com";
                objectUnderTest.Text = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.Text)) || expectedValue == objectUnderTest.Text);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void MaskedEditValidatorTests_Property_ValidationGroup_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.String expectedValue;
        
            
            try
            {
                expectedValue = null;
                objectUnderTest.ValidationGroup = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ValidationGroup)) || expectedValue == objectUnderTest.ValidationGroup);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "";
                objectUnderTest.ValidationGroup = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ValidationGroup)) || expectedValue == objectUnderTest.ValidationGroup);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1";
                objectUnderTest.ValidationGroup = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ValidationGroup)) || expectedValue == objectUnderTest.ValidationGroup);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "x";
                objectUnderTest.ValidationGroup = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ValidationGroup)) || expectedValue == objectUnderTest.ValidationGroup);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = ",";
                objectUnderTest.ValidationGroup = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ValidationGroup)) || expectedValue == objectUnderTest.ValidationGroup);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "123";
                objectUnderTest.ValidationGroup = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ValidationGroup)) || expectedValue == objectUnderTest.ValidationGroup);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "abc";
                objectUnderTest.ValidationGroup = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ValidationGroup)) || expectedValue == objectUnderTest.ValidationGroup);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1,2,3";
                objectUnderTest.ValidationGroup = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ValidationGroup)) || expectedValue == objectUnderTest.ValidationGroup);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a,b,c";
                objectUnderTest.ValidationGroup = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ValidationGroup)) || expectedValue == objectUnderTest.ValidationGroup);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1;2;3";
                objectUnderTest.ValidationGroup = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ValidationGroup)) || expectedValue == objectUnderTest.ValidationGroup);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a;b;c";
                objectUnderTest.ValidationGroup = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ValidationGroup)) || expectedValue == objectUnderTest.ValidationGroup);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "http://test.com";
                objectUnderTest.ValidationGroup = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ValidationGroup)) || expectedValue == objectUnderTest.ValidationGroup);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "test@test.com";
                objectUnderTest.ValidationGroup = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ValidationGroup)) || expectedValue == objectUnderTest.ValidationGroup);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void MaskedEditValidatorTests_Property_AccessKey_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.String expectedValue;
        
            
            try
            {
                expectedValue = null;
                objectUnderTest.AccessKey = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AccessKey)) || expectedValue == objectUnderTest.AccessKey);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "";
                objectUnderTest.AccessKey = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AccessKey)) || expectedValue == objectUnderTest.AccessKey);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1";
                objectUnderTest.AccessKey = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AccessKey)) || expectedValue == objectUnderTest.AccessKey);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "x";
                objectUnderTest.AccessKey = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AccessKey)) || expectedValue == objectUnderTest.AccessKey);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = ",";
                objectUnderTest.AccessKey = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AccessKey)) || expectedValue == objectUnderTest.AccessKey);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "123";
                objectUnderTest.AccessKey = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AccessKey)) || expectedValue == objectUnderTest.AccessKey);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "abc";
                objectUnderTest.AccessKey = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AccessKey)) || expectedValue == objectUnderTest.AccessKey);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1,2,3";
                objectUnderTest.AccessKey = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AccessKey)) || expectedValue == objectUnderTest.AccessKey);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a,b,c";
                objectUnderTest.AccessKey = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AccessKey)) || expectedValue == objectUnderTest.AccessKey);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1;2;3";
                objectUnderTest.AccessKey = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AccessKey)) || expectedValue == objectUnderTest.AccessKey);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a;b;c";
                objectUnderTest.AccessKey = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AccessKey)) || expectedValue == objectUnderTest.AccessKey);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "http://test.com";
                objectUnderTest.AccessKey = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AccessKey)) || expectedValue == objectUnderTest.AccessKey);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "test@test.com";
                objectUnderTest.AccessKey = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AccessKey)) || expectedValue == objectUnderTest.AccessKey);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void MaskedEditValidatorTests_Property_CssClass_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.String expectedValue;
        
            
            try
            {
                expectedValue = null;
                objectUnderTest.CssClass = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CssClass)) || expectedValue == objectUnderTest.CssClass);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "";
                objectUnderTest.CssClass = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CssClass)) || expectedValue == objectUnderTest.CssClass);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1";
                objectUnderTest.CssClass = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CssClass)) || expectedValue == objectUnderTest.CssClass);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "x";
                objectUnderTest.CssClass = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CssClass)) || expectedValue == objectUnderTest.CssClass);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = ",";
                objectUnderTest.CssClass = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CssClass)) || expectedValue == objectUnderTest.CssClass);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "123";
                objectUnderTest.CssClass = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CssClass)) || expectedValue == objectUnderTest.CssClass);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "abc";
                objectUnderTest.CssClass = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CssClass)) || expectedValue == objectUnderTest.CssClass);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1,2,3";
                objectUnderTest.CssClass = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CssClass)) || expectedValue == objectUnderTest.CssClass);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a,b,c";
                objectUnderTest.CssClass = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CssClass)) || expectedValue == objectUnderTest.CssClass);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1;2;3";
                objectUnderTest.CssClass = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CssClass)) || expectedValue == objectUnderTest.CssClass);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a;b;c";
                objectUnderTest.CssClass = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CssClass)) || expectedValue == objectUnderTest.CssClass);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "http://test.com";
                objectUnderTest.CssClass = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CssClass)) || expectedValue == objectUnderTest.CssClass);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "test@test.com";
                objectUnderTest.CssClass = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.CssClass)) || expectedValue == objectUnderTest.CssClass);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void MaskedEditValidatorTests_Property_EnableTheming_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.Boolean expectedValue;
        
            
            try
            {
                expectedValue = true;
                objectUnderTest.EnableTheming = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.EnableTheming);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = false;
                objectUnderTest.EnableTheming = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.EnableTheming);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void MaskedEditValidatorTests_Property_SkinID_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.String expectedValue;
        
            
            try
            {
                expectedValue = null;
                objectUnderTest.SkinID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.SkinID)) || expectedValue == objectUnderTest.SkinID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "";
                objectUnderTest.SkinID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.SkinID)) || expectedValue == objectUnderTest.SkinID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1";
                objectUnderTest.SkinID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.SkinID)) || expectedValue == objectUnderTest.SkinID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "x";
                objectUnderTest.SkinID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.SkinID)) || expectedValue == objectUnderTest.SkinID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = ",";
                objectUnderTest.SkinID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.SkinID)) || expectedValue == objectUnderTest.SkinID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "123";
                objectUnderTest.SkinID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.SkinID)) || expectedValue == objectUnderTest.SkinID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "abc";
                objectUnderTest.SkinID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.SkinID)) || expectedValue == objectUnderTest.SkinID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1,2,3";
                objectUnderTest.SkinID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.SkinID)) || expectedValue == objectUnderTest.SkinID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a,b,c";
                objectUnderTest.SkinID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.SkinID)) || expectedValue == objectUnderTest.SkinID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1;2;3";
                objectUnderTest.SkinID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.SkinID)) || expectedValue == objectUnderTest.SkinID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a;b;c";
                objectUnderTest.SkinID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.SkinID)) || expectedValue == objectUnderTest.SkinID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "http://test.com";
                objectUnderTest.SkinID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.SkinID)) || expectedValue == objectUnderTest.SkinID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "test@test.com";
                objectUnderTest.SkinID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.SkinID)) || expectedValue == objectUnderTest.SkinID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void MaskedEditValidatorTests_Property_TabIndex_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.Int16 expectedValue;
        
            
            try
            {
                expectedValue = Int16.MinValue;
                objectUnderTest.TabIndex = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.TabIndex);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = (System.Int16)(-1);
                objectUnderTest.TabIndex = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.TabIndex);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = (System.Int16)0;
                objectUnderTest.TabIndex = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.TabIndex);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = (System.Int16)1;
                objectUnderTest.TabIndex = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.TabIndex);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = Int16.MaxValue;
                objectUnderTest.TabIndex = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.TabIndex);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void MaskedEditValidatorTests_Property_ToolTip_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.String expectedValue;
        
            
            try
            {
                expectedValue = null;
                objectUnderTest.ToolTip = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ToolTip)) || expectedValue == objectUnderTest.ToolTip);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "";
                objectUnderTest.ToolTip = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ToolTip)) || expectedValue == objectUnderTest.ToolTip);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1";
                objectUnderTest.ToolTip = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ToolTip)) || expectedValue == objectUnderTest.ToolTip);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "x";
                objectUnderTest.ToolTip = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ToolTip)) || expectedValue == objectUnderTest.ToolTip);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = ",";
                objectUnderTest.ToolTip = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ToolTip)) || expectedValue == objectUnderTest.ToolTip);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "123";
                objectUnderTest.ToolTip = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ToolTip)) || expectedValue == objectUnderTest.ToolTip);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "abc";
                objectUnderTest.ToolTip = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ToolTip)) || expectedValue == objectUnderTest.ToolTip);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1,2,3";
                objectUnderTest.ToolTip = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ToolTip)) || expectedValue == objectUnderTest.ToolTip);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a,b,c";
                objectUnderTest.ToolTip = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ToolTip)) || expectedValue == objectUnderTest.ToolTip);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1;2;3";
                objectUnderTest.ToolTip = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ToolTip)) || expectedValue == objectUnderTest.ToolTip);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a;b;c";
                objectUnderTest.ToolTip = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ToolTip)) || expectedValue == objectUnderTest.ToolTip);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "http://test.com";
                objectUnderTest.ToolTip = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ToolTip)) || expectedValue == objectUnderTest.ToolTip);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "test@test.com";
                objectUnderTest.ToolTip = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ToolTip)) || expectedValue == objectUnderTest.ToolTip);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void MaskedEditValidatorTests_Property_ID_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.String expectedValue;
        
            
            try
            {
                expectedValue = null;
                objectUnderTest.ID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ID)) || expectedValue == objectUnderTest.ID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "";
                objectUnderTest.ID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ID)) || expectedValue == objectUnderTest.ID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1";
                objectUnderTest.ID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ID)) || expectedValue == objectUnderTest.ID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "x";
                objectUnderTest.ID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ID)) || expectedValue == objectUnderTest.ID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = ",";
                objectUnderTest.ID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ID)) || expectedValue == objectUnderTest.ID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "123";
                objectUnderTest.ID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ID)) || expectedValue == objectUnderTest.ID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "abc";
                objectUnderTest.ID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ID)) || expectedValue == objectUnderTest.ID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1,2,3";
                objectUnderTest.ID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ID)) || expectedValue == objectUnderTest.ID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a,b,c";
                objectUnderTest.ID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ID)) || expectedValue == objectUnderTest.ID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1;2;3";
                objectUnderTest.ID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ID)) || expectedValue == objectUnderTest.ID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a;b;c";
                objectUnderTest.ID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ID)) || expectedValue == objectUnderTest.ID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "http://test.com";
                objectUnderTest.ID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ID)) || expectedValue == objectUnderTest.ID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "test@test.com";
                objectUnderTest.ID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ID)) || expectedValue == objectUnderTest.ID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void MaskedEditValidatorTests_Property_EnableViewState_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.Boolean expectedValue;
        
            
            try
            {
                expectedValue = true;
                objectUnderTest.EnableViewState = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.EnableViewState);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = false;
                objectUnderTest.EnableViewState = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.EnableViewState);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void MaskedEditValidatorTests_Property_AppRelativeTemplateSourceDirectory_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.String expectedValue;
        
            
            try
            {
                expectedValue = null;
                objectUnderTest.AppRelativeTemplateSourceDirectory = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AppRelativeTemplateSourceDirectory)) || expectedValue == objectUnderTest.AppRelativeTemplateSourceDirectory);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "";
                objectUnderTest.AppRelativeTemplateSourceDirectory = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AppRelativeTemplateSourceDirectory)) || expectedValue == objectUnderTest.AppRelativeTemplateSourceDirectory);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1";
                objectUnderTest.AppRelativeTemplateSourceDirectory = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AppRelativeTemplateSourceDirectory)) || expectedValue == objectUnderTest.AppRelativeTemplateSourceDirectory);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "x";
                objectUnderTest.AppRelativeTemplateSourceDirectory = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AppRelativeTemplateSourceDirectory)) || expectedValue == objectUnderTest.AppRelativeTemplateSourceDirectory);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = ",";
                objectUnderTest.AppRelativeTemplateSourceDirectory = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AppRelativeTemplateSourceDirectory)) || expectedValue == objectUnderTest.AppRelativeTemplateSourceDirectory);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "123";
                objectUnderTest.AppRelativeTemplateSourceDirectory = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AppRelativeTemplateSourceDirectory)) || expectedValue == objectUnderTest.AppRelativeTemplateSourceDirectory);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "abc";
                objectUnderTest.AppRelativeTemplateSourceDirectory = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AppRelativeTemplateSourceDirectory)) || expectedValue == objectUnderTest.AppRelativeTemplateSourceDirectory);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1,2,3";
                objectUnderTest.AppRelativeTemplateSourceDirectory = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AppRelativeTemplateSourceDirectory)) || expectedValue == objectUnderTest.AppRelativeTemplateSourceDirectory);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a,b,c";
                objectUnderTest.AppRelativeTemplateSourceDirectory = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AppRelativeTemplateSourceDirectory)) || expectedValue == objectUnderTest.AppRelativeTemplateSourceDirectory);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1;2;3";
                objectUnderTest.AppRelativeTemplateSourceDirectory = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AppRelativeTemplateSourceDirectory)) || expectedValue == objectUnderTest.AppRelativeTemplateSourceDirectory);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a;b;c";
                objectUnderTest.AppRelativeTemplateSourceDirectory = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AppRelativeTemplateSourceDirectory)) || expectedValue == objectUnderTest.AppRelativeTemplateSourceDirectory);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "http://test.com";
                objectUnderTest.AppRelativeTemplateSourceDirectory = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AppRelativeTemplateSourceDirectory)) || expectedValue == objectUnderTest.AppRelativeTemplateSourceDirectory);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "test@test.com";
                objectUnderTest.AppRelativeTemplateSourceDirectory = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.AppRelativeTemplateSourceDirectory)) || expectedValue == objectUnderTest.AppRelativeTemplateSourceDirectory);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void MaskedEditValidatorTests_Property_Visible_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.Boolean expectedValue;
        
            
            try
            {
                expectedValue = true;
                objectUnderTest.Visible = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.Visible);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = false;
                objectUnderTest.Visible = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.Visible);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
    }
}

